Overview
What is Redis™*?
Redis is an open source in-memory data structure server and NoSQL database.
TrustRadius Insights
Best open-source caching database
Set up & forget
Redis is THE solution to all your caching problems
Great in-memory database solution
Redis is a great product offering from Amazon
REDIS great as K/V cache
Redis Review
Redis Solves many application caching problems.
Fast and reliable
Best DB for a gaming company willing to scale overnight
Redis is awesome!
Redis will improve reliability and performance and reduced costs.
Improve performance at a reduced cost
Gets the job done!
Awards
Products that are considered exceptional by their customers based on a variety of criteria win TrustRadius awards. Learn more about the types of TrustRadius awards to make the best purchase decision. More about TrustRadius Awards
Popular Features
- Performance (69)10.0100%
- Scalability (69)9.494%
- Availability (69)9.090%
- Concurrency (68)9.090%
Reviewer Pros & Cons
Pricing
Cloud
$388.00
Entry-level set up fee?
- Setup fee optional
Offerings
- Free Trial
- Free/Freemium Version
- Premium Consulting/Integration Services
Features
NoSQL Databases
NoSQL databases are designed to be used across large distrusted systems. They are notably much more scalable and much faster and handling very large data loads than traditional relational databases.
- 10Performance(69) Ratings
How fast the database performs under data load
- 9Availability(69) Ratings
Availability is the probability that the NoSQL database will be available to preform its function when called upon.
- 9Concurrency(68) Ratings
Concurrency is the ability for multiple processes to access or change shared data simultaneously. The greater the number of concurrent user processes that can execute without blocking each other, the greater the concurrency of the database system.
- 8Security(63) Ratings
Security features include authentication against external security mechanisms liker LDAP, Windows Active Directory, and authorization or privilege management. Some NoSQL databases also support encryption.
- 9.4Scalability(69) Ratings
NoSQL databases are inherently more stable than relational databases and have built-in support for replication and partitioning of data to support scalability.
- 9.9Data model flexibility(62) Ratings
NoSQL databases do not rely on rely on tables, columns, rows, or schemas to organize and retrieve data, but use use more flexible data models to accommodate the large volume and variety of data being generated by modern applications.
- 9.3Deployment model flexibility(62) Ratings
Can be deployed on-premise or in the cloud.
Product Details
- About
- Integrations
- Competitors
- Tech Details
- Downloadables
- FAQs
What is Redis™*?
According to the vendor, Redis is an in-memory multi-model database that supports multiple data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs and geospatial indexes with radius queries. Redis has built-in replication, Lua scripting, LRU eviction, transactions and different levels of on-disk persistence, and provides high availability and automatic partitioning with Redis Cluster.
Redis combines in-memory, schema-less design with optimized data structures and versatile modules that adapt to your data needs. The result is an adept, high performance, multi-purpose database that scales easily like a simple key/value data store but delivers sophisticated functionality with great simplicity, according to the vendor.
Redis also enables data persistence and high availability through replication and backups. Redis Enterprise is built from the ground up to serve as a system of record for any application.
*Redis is a trademark of Redis Ltd. Any rights therein are reserved to Redis Ltd. Any use by TrustRadius is for referential purposes only and does not indicate any sponsorship, endorsement or affiliation between Redis and TrustRadius.
Redis™* Features
NoSQL Databases Features
- Supported: Performance
- Supported: Availability
- Supported: Concurrency
- Supported: Security
- Supported: Scalability
- Supported: Data model flexibility
- Supported: Deployment model flexibility
Additional Features
- Supported: Integrated modules
- Supported: Active-Passive Geo Distribution
- Supported: Cluster Architecture
- Supported: Linear Scaling
- Supported: Durability
- Supported: Backup and Disaster Recovery
- Supported: Reliability
Redis™* Screenshots
Redis™* Video
Redis™* Integrations
- Apache Spark
- Red Hat OpenShift
- CData
- Pivotal Cloud Foundry
Redis™* Competitors
Redis™* Technical Details
Deployment Types | On-premise, Software as a Service (SaaS), Cloud, or Web-Based |
---|---|
Operating Systems | Windows, Linux, Mac |
Mobile Application | Apple iOS, Android, Windows Phone, Blackberry, Mobile Web |
Supported Countries | Global |
Supported Languages | https://redis.io/clients |
Redis™* Downloadables
Frequently Asked Questions
Comparisons
Compare with
Reviews and Ratings
(224)Community Insights
- Business Problems Solved
- Recommendations
Redis has proven itself to be an invaluable tool in a wide range of use cases. Users have found Redis to be exceptional as an efficient caching solution, allowing for the distribution of data and storage of web sessions. This capability has led to significant improvements in performance and reliability, making it a go-to choice for many backend development teams. Additionally, Redis's versatility as a NoSQL key-based database store has made it a preferred option for organizations working alongside other databases like PostgreSQL and Memcache. Its ease of use, stability, and reliability have made it a popular choice across multiple departments within organizations.
Furthermore, Redis has been leveraged in various R&D projects to experiment with its implementation in different modules. Starting with cache management, users have been able to extend its usage to address specific project needs effectively. In these experiments, Redis has served as a traditional in-memory key store warehouse for cache systems with a vast number of items, resulting in substantial latency savings. Its ability to manage distributed queues efficiently has also made Redis an excellent choice for tasks that require multiple worker nodes to subscribe and complete tasks. The flexibility Redis offers by enabling users to store sets of object-based information and lists further improves performance through set operations.
In addition to these use cases, Redis has become synonymous with simplicity and speed when it comes to basic yet fast key-value storage solutions. It has been extensively adopted in organizations, including game studios, where it is used for storing user data, session data, game data, and indexing information. For example, Redis Enterprise has been utilized to support backend systems for casual games by providing sub-millisecond response times and facilitating clustering, sharding, backups, and monitoring.
Moreover, customers have found Redis instrumental in addressing various challenges such as big data processing, handling temporal data, managing session state, and even as a caching service in microservices environments. Its ability to provide data consistency, concurrency management, and high-speed operations has proven invaluable. Additionally, Redis has been a reliable tool for caching solutions in e-commerce storefronts and data visualization applications. Users have reported reduced server load and improved performance as a result of implementing Redis as a cache.
Redis has also found success as a buffer cache, allowing for faster data retrieval and improved overall database performance. Its role in processing queues, calling APIs, and supporting vital organizational workflows has been recognized by customers who rely on its stability and speed. Furthermore, users have implemented Redis across various domains to manage user timelines, build notification systems, and implement microservices architecture
Users recommend the following for Redis:
Consider other cache options before choosing Redis. It is advisable to try out other caching solutions before jumping to Redis, even though it is a great tool for highly distributed caching.
Understand the purpose of Redis in your implementation. It is important to have a clear understanding of how Redis will be used in your specific application. Don't assume that it will work straight out of the box. Evaluate data structures and choose a model that allows for faster query times.
Use Redis for specific use cases. Redis shines in certain areas such as synchronizing states across instances and handling user sessions with Node.js. It can also be a good alternative for relational data when speed is of utmost importance. However, users caution against abusing Redis and recommend using it in a reasonable way.
Overall, users believe that Redis is a valuable tool for fast reliable storage and caching, particularly for enterprise applications. However, they also advise considering other key-value stores depending on the specific use case at hand.
Attribute Ratings
Reviews
(1-25 of 47)Blazing performance, excellent stability, and really nothing to dislike make Redis a must look at solution
- Cache speed
- Support for high volume of transactions with elegant handling of data sets
- Ease of use - well structured and easy to implement
- Price per shard is a bit high but over all there are no issues worth mentioning
- I've heard some wishing it supported complex queries but this is asking the solution to support operations it wasn't intended for
- Big data manipulation
- Temporal data index structures
- Distributed solutions
- Publish/Subscribe model based solutions
Best open-source caching database
- A modern key-value store in-memory database.
- Redis [is thorough] and details user documentation.
- Data distribution on a multi-tenant cluster is easy and reliable.
- It lacks support for datatypes that are available on other products.
- Making it work with Celery is a bit hard and sometime it's not reliable.
- Lacks better UI like other systems.
The ramp up and integration was quite easy.
Redis handles automatic failover internally, so no crashes provides high availability.
On the fly scaling scale to more/less cores and memory as and when needed.
Set up & forget
- Has been working well for storing user sessions.
- No need for maintenance operations. Once it's set up has been working flawlessly.
- Many configuration options, little programming required.
- The actual database structure is difficult to understand.
- Only command line application available for free. Difficult to use.
- Seems to have some encoding issues when inspecting data directly with CLI app.
Redis is THE solution to all your caching problems
- Great performance for reading data
- Easy to set up and work with
- Great support for many different types of data structure
- Lacking monitoring and administration tools
- System resource consumption as you scale up
Redis is a great product offering from Amazon
- As with other service offerings from Amazon, Redis is fully managed as well and eliminates a lot of burden on our team.
- It's easy to get hold of all the metrics as it is integrated with Cloudwatch.
- Very quick and easy to deploy and configure the Redis services into our environment.
- It becomes expensive over time and need to keep a close watch on the usage.
- If the instance goes down, there is no backup preserved.
REDIS great as K/V cache
- Quick key lookups.
- Distribution of data is easy and reliable.
- Almost HA.
- HA automatic failover for master and promoting slave on own.
- Doesn't handle 1M r/s sadly.
- Cross DC replication not so great.
Redis is awesome!
- Redis has many data types that suit a variety of use cases such as caching, message queues, graphs.
- Redis is an open-sourced tool with a growing community, as well as 3rd party support (Amazon managed version) if you need additional help with the set-up.
- Both the clients and the command line tool are easy to use and well-documented.
- Scaling has always been an issue with Redis. Routing to shards is not automatic.
- There's no GUI for managing the keys and values stored in Redis. The command-line tool is useful but not friendly to non-engineering users.
- The data types as in data structures have many choices, but inside of the key-value pair, the content is always stored as a string.
- Great reliability and great fail over capabilities
- Easy to set up, implement and deploy
- Can scale as you grow
- Backups to AWS S3 are supported and are very easy to set up
- Better UI interface for less technical support personnel
- Wish Reids had a Chat support option
- Better documentation in a wiki format
Improve performance at a reduced cost
- Great fail over capabilities for optimal up time
- Very easy to set up and get running
- Create backups to AWS S3
- Clustering for greater performance is very easy
- Able to scale is easy to set up and can build with your needs
- Complete data sets tend to have some difficulty. But that's mostly on the type of code you're running
- Only one module can be active at one time. Wish you could run multiple
Gets the job done!
- Ease of use and set-up.
- Clustering and sharding.
- Automated backups to remote storage (S3).
- The documentation grows quite fast (200+ commands), perhaps they should have a most-used ranking.
- Redis modules (Bloom, JSON, Search) are great, but only one can be active at a time.
Redis, a fast, reliable and well supported data storage system
- Atomic operations
- Quick Lookups
- Widely supported (there are many tools/libraries built over Redis)
- We had some difficulty scaling Redis without it becoming prohibitively expensive.
- Redis has very simple search capabilities, which means its not suitable for all use cases.
- Redis doesn't have good native support for storing data in object form and many libraries built over it return data as a string, meaning you need build your own serialization layer over it.
Conversely, due to price/data I wouldn't recommend Redis for persisted or infrequently accessed data.
Redis is Awesome
- Easy for developers to understand. Unlike Riak, which I've used in the past, it's fast without having to worry about eventual consistency.
- Reliable. With a proper multi-node configuration, it can handle failover instantly.
- Configurable. We primarily still use Memcache for caching but one of the teams uses Redis for both long-term storage and temporary expiry keys without taking on another external dependency.
- Fast. We process tens of thousands of RPS and it doesn't skip a beat.
- Autoscale. We've used Redis at RedisLabs and currently on AWS with ElastiCache plus previously I've self-hosted it and there are no real options for "serverless" or an operating model whereby I'm using only the resources needed to handle my current volume, instead, everything is provisioned and sized to your highest throughput needs. For us, that's only a few hours a day where we're at our peak, the other 16 hours could run smaller hardware but the system doesn't autoscale up/down seamlessly on any of the platform providers.
- Management console. Some systems such as Riak have a built-in GUI for ops or Mongo runs their own Compass product but Redis seems to entirely rely on other OSS solutions, which is great, but having a built-in tool that's lock-step with the released versions would ease any quick troubleshooting that CLI-challenged ops teams could utilize.
- Redis replication is asynchronous. Therefore, when a primary cluster fails over to a replica, a small amount of data might be lost due to replication lag.
Redis is a great solution for any company that wants fast development and good performance
- Key-value access, very fast.
- Caching - either using hashmaps or simple values.
- The Python package elastic DSL is somehow incomplete.
- Moving from a Python client to Redis 2 to Redis 3 is a mess.
Super fast and easy to integrate
The great thing about this is also that each cluster can be running a different version of our application allowing us to maintain a high level of robustness for our larger enterprise customers, while also allowing us to deploy frequently to other clusters that want the bleeding edge. With Redis, being able to determine the right cluster for the right request happens blazing fast.
- FAST LOOKUPS. First and foremost, this is the bread and butter of Redis. It is our go-to for any highly performant lookups.
- SCALE OUT. Helps build distributed applications that need to share data across geographies.
- Better GUI clients. At the time of adoption, the choices for UI based clients were poor. Such tools are necessary for tier 1 support personnel who may not be entirely technically savvy.
Redis Review
- Storing geolocations - Redis has built-in geolocation storage capabilities, thus saving us the time of developing the logic ourselves.
- Serving fast info for real-time apps - To anyone who works with real-time applications, fast information is the basis of good user experiences.
- I think the documentation could improve. It's not always clear, especially for engineers that are new on Redis.
- Redislabs admin interface could use a tune-up, maybe being more informative and with a better UI.
- I think the main cons I see in Redis could be that it may be a bit too obscure to new users.
Enterprise performance at a fraction of the price
- In-memory datasets.
- Computing set intersection.
- Automatic failover.
- Tech support.
- More user forums.
- A Wiki-style support page.
Redis is battle-tested
- Helpful customer support.
- Reasonable pricing.
- Keeps Redis software secure and up-to-date quietly in the background.
- Replies from customer support via could be a little faster. We're on the basic plan, and it can take up to 2 business days--it's not fast enough when your bugs need to be solved right away.
Reduced costs
- Speeds up database searches.
- Cloud-based without the need for on-prem.
- High availability.
- Support needs to be better, with chat support as an option.
- Training material for new hire dev-ops.
- Wiki-type documentation.
Redis is great when you use it correctly.
- Fast key value store
- Serializable concurrent usage (by virtue of being single-threaded)
- Wide library support
- Failover is terrifying and its safety guarantees are misleading
- Large sets (> 500k entries) have noticeable performance degradation on what is advertised to be a O(1) query pattern
- Hardware costs are high
Cache in action
- We used cache data to speed up the processing power.
- To do intersections of various sets and achieve a high performing solution.
- To use it as a second-level cache for large data.
- Luva script is a pain to work on
Perfect for caching and expiring data storage
- Really fast.
- Data model simple to understand.
- Very simple to use.
- Support batches of operations to increase performances.
- Nothing, it just works.
- Cache
- Filtering out duplicates
- Implement rate limits
- Store access tokens or revoked credentials
- Storing complex data (go for a traditional database instead)
Honest hands-on review of Redis
- It's easy to manage.
- It fits most simple caching use cases.
- Can be clustered.
- Highly configurable.
- Clustering can be easier to set up.
- Sharing data can be challenging.
Things you can do with Redis
- Excellent performance
- Scalability
- Reliability
- Real-time analytics
- Few commands
When it comes to performing analytics, Redis is very efficient at that as well as handling large amounts of data common in the data analytics industry. Redis also acts as a very excellent NoSQL database.
Redis analysis
- Atomic counters
- Cache colocated with other services that require low latencies
- Automatic memory management
- CLI could be improved
- Configuration management
- Replication and snarfing
Redis: the best cache store you can get!
- High-speed access for a database where the size is generally well-known.
- If you display real-time stock prices, you can use Redis to rapidly get the latest stock price by its key and get it displayed to the user.
- Support for data structures such as scalars, sets, hashes, and lists.
- Persistence can impact performance since Redis will use memory dump to create snapshots used for persistence.
- Redis supports only basic security options. Redis doesn't provide any access control.
- There is no internal full-text search support and it is difficult to model relationships using Redis.